package oj0306;

import java.util.Scanner;

class SeqList {
    private static final int maxSize = 10;//顺序表的长度不超过10
    private int[] data;
    private int length;

    // 默认构造函数
    public SeqList() {
        /* 开辟顺序表空间 */
        data = new int[maxSize];
        /* 设置长度为 0 */
        length = 0;
    }

    // 带参构造函数
    public SeqList(int a[], int n) {
        /* 开辟顺序表空间 */
        data = new int[maxSize];
        /* 如果超出线性表的最大容量，则构建失败，直接返回(不用输出错误信息) */
        if (n > maxSize) {
            return;
        }
        /* 传入一个长度为n的数组a，初始化线性表 */
        for (int i = 0; i < n; i++) {
            data[i] = a[i];
        }
        length = n;
    }
    //返回长度
    public int getLength() {
        return length;
    }

    // 输出线性表
    public void printList() {
        /* 如果线性表为空或超出容量，则什么都不输出 */
        if (length == 0 || length > maxSize) {
            return;
        }
        /* 线性表元素每两个之间用空格隔开，最后一个元素后没有空格，然后换行 */
        for (int i = 0; i < length; i++) {
            if (i == length - 1) {
                System.out.println(data[i]);
            } else {
                System.out.print(data[i] + " ");
            }
        }
    }


    // 返回线性表是否为空
    public boolean isEmpty() {
        /* 空则返回true，非空则返回false*/
        return length == 0;
    }

    /* 按位查找：返回线性表第i个元素 */
    public int getElement(int i) {
        /* 位置从1开始计数，下标从0开始计数，若线性表中不存在位置i，返回-1(不用输出错误信息) */
        if (isEmpty()) {
            System.out.println("Empty list");
            return -1;
        }
        if (i < 1 || i > length){
            System.out.println("The search position is invalid");
            return -1;
        }
        return data[i - 1];
    }

    /* 按值查找：返回元素x第一次出现的位置 */
    public int locate(int x) {
        /* 位置从1开始计数，下标从0开始计数，若线性表中没有元素x，返回-1(不用输出错误信息) */
        for (int i = 0; i < length; i++) {
            if (data[i] == x) {
                return i + 1;
            }
        }
        System.out.println("The element being searched for does not exist");
        return -1;
    }

    /*
        在第1题的基础上，并仿造第2题，在类声明中，增加插入元素的函数void Insert(int i, int x)。函数的功能如下：
        顺序表的位置从1开始计数，下标是从0开始计数，若插入位置错误，或线性表已经达到最大容量，则什么也不做；
        正常：例如当前线性表为[5,3,4], i=2, x=1, 操作完后线性表应变为[5,1,3,4]；
        插入位置错误：例如当前线性表为[5,3,4], i=5, x=1, 操作完后线性表仍然是[5,3,4]；
        线性表已经达到最大容量：假设线性表的最大容量为5，例如当前线性表为[5,3,4,1,2], i=1, x=1, 操作完后线性表仍然是[5,3,4,1,2]。
        main函数也需要在原来的基础上做一些符合题目要求的改造。
        ****i 要插入的下标，x 要插入的元素****
     */
    public void insert(int i, int x) {
//        插入位置错误，或线性表已经达到最大容量，return
        if (length >= maxSize ) {
            System.out.println("Overflow");
            return;
        }
        if(i < 1 || i > length + 1){
            System.out.println("The insert position is invalid");
            return;
        }
//        遍历从最后一个元素开始
        for (int index = length; index >= i; index--) {
            data[index] = data[index - 1];
        }
        data[i - 1] = x;
        length ++;
    }
    /*删除*/
    public int delete(int i){
        int x;
        if (length == 0) {
            System.out.println("Empty list");
            return -1;
        }
        if ( i < 1 || i > length) {
            System.out.println("The delete position is invalid");
            return -1;
        }
        x = data[i - 1];
        for (int ind = i;ind<length;ind++) {
            data[ind - 1] = data[ind];
        }
        length --;
        return x;
    }
};

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();   //初始元素个数
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }
        SeqList seqList = new SeqList(a, n);// 创建顺序表对象
        while (true) {
            int i = sc.nextInt();   //第一个输入的数
            if (i > 6 || i < 0){
                break;
            }
            if (i == 0){
                break;
            }
            int x,y,res;
            switch (i){
                case 1:
                    x = sc.nextInt();
                    y = sc.nextInt();
                    seqList.insert(x, y);
//                    seqList.printList();
                    break;
                case 2:
                    x = sc.nextInt();
//                    System.out.println(seqList.delete(i));
                    res = seqList.delete(x);
                    if (res != -1){
                        System.out.println(res);
                    }
//                    seqList.printList();
                    break;
                case 3:
                    x = sc.nextInt();
//                    System.out.println(seqList.getElement(x));
                    res = seqList.getElement(x);
                    if (res != -1) {
                        System.out.println(res);
                    }
//                    seqList.printList();
                    break;
                case 4:
                    x = sc.nextInt();
                    res = seqList.locate(x);
                    if (res != -1){
                        System.out.println(res);
                    }

//                    seqList.printList();
                    break;
                case 5:
                    System.out.println(seqList.getLength());
//                    seqList.printList();
                    break;
                case 6:
                    seqList.printList();
                    break;
                default:
                    break;
            }
        }
        sc.close();

    }
}